# Importation des bibliothèques nécessaires
import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pd
import numpy as np
from sklearn.tree import DecisionTreeClassifier, plot_tree
from sklearn.model_selection import train_test_split,cross_val_score
from sklearn.metrics import classification_report
La base de données "Diabetes" est disponible sur Kaggle. Cette base de données contient des informations sur des patientes féminines âgées d'au moins 21 ans et provenant de populations amérindiennes Pima, qui ont été examinées pour déterminer s'ils avaient un diabète de type 2. Les caractéristiques incluent des mesures telles que la taille, le poids, l'âge, le nombre de grossesses, la pression artérielle, etc.
La base de données contient les colonnes suivantes :
Pregnancies : nombre de grossessesGlucose : concentration de glucose dans le plasma sanguin à jeunBloodPressure : pression artérielle diastolique (mm Hg)SkinThickness : épaisseur du pli cutané tricipital (mm)Insulin : taux d'insuline sérique de 2 heures (mu U/ml)BMI : indice de masse corporelle (kg/m²)DiabetesPedigreeFunction : fonction pedigree du diabèteAge : âge (années)Outcome : variable cible indiquant si le patient est diabétique (0 = non diabétique, 1 = diabétique)L'objectif de cette analyse est de construire un modèle de classification pour prédire si une patiente a un diabète de type 2 en fonction de ses caractéristiques cliniques. Cette base de données sera divisée en ensembles d'apprentissage et de test pour entraîner et évaluer les performances du modèle.
# Chargement des données
diabete=pd.read_csv("diabetes.csv")
diabete.head()
| Pregnancies | Glucose | BloodPressure | SkinThickness | Insulin | BMI | DiabetesPedigreeFunction | Age | Outcome | |
|---|---|---|---|---|---|---|---|---|---|
| 0 | 6 | 148 | 72 | 35 | 0 | 33.6 | 0.627 | 50 | 1 |
| 1 | 1 | 85 | 66 | 29 | 0 | 26.6 | 0.351 | 31 | 0 |
| 2 | 8 | 183 | 64 | 0 | 0 | 23.3 | 0.672 | 32 | 1 |
| 3 | 1 | 89 | 66 | 23 | 94 | 28.1 | 0.167 | 21 | 0 |
| 4 | 0 | 137 | 40 | 35 | 168 | 43.1 | 2.288 | 33 | 1 |
# Affichage des informations générales sur le DataFrame
diabete.info()
<class 'pandas.core.frame.DataFrame'> RangeIndex: 768 entries, 0 to 767 Data columns (total 9 columns): # Column Non-Null Count Dtype --- ------ -------------- ----- 0 Pregnancies 768 non-null int64 1 Glucose 768 non-null int64 2 BloodPressure 768 non-null int64 3 SkinThickness 768 non-null int64 4 Insulin 768 non-null int64 5 BMI 768 non-null float64 6 DiabetesPedigreeFunction 768 non-null float64 7 Age 768 non-null int64 8 Outcome 768 non-null int64 dtypes: float64(2), int64(7) memory usage: 54.1 KB
# Affichage des statistiques descriptives du DataFrame
diabete.describe()
| Pregnancies | Glucose | BloodPressure | SkinThickness | Insulin | BMI | DiabetesPedigreeFunction | Age | Outcome | |
|---|---|---|---|---|---|---|---|---|---|
| count | 768.000000 | 768.000000 | 768.000000 | 768.000000 | 768.000000 | 768.000000 | 768.000000 | 768.000000 | 768.000000 |
| mean | 3.845052 | 120.894531 | 69.105469 | 20.536458 | 79.799479 | 31.992578 | 0.471876 | 33.240885 | 0.348958 |
| std | 3.369578 | 31.972618 | 19.355807 | 15.952218 | 115.244002 | 7.884160 | 0.331329 | 11.760232 | 0.476951 |
| min | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.078000 | 21.000000 | 0.000000 |
| 25% | 1.000000 | 99.000000 | 62.000000 | 0.000000 | 0.000000 | 27.300000 | 0.243750 | 24.000000 | 0.000000 |
| 50% | 3.000000 | 117.000000 | 72.000000 | 23.000000 | 30.500000 | 32.000000 | 0.372500 | 29.000000 | 0.000000 |
| 75% | 6.000000 | 140.250000 | 80.000000 | 32.000000 | 127.250000 | 36.600000 | 0.626250 | 41.000000 | 1.000000 |
| max | 17.000000 | 199.000000 | 122.000000 | 99.000000 | 846.000000 | 67.100000 | 2.420000 | 81.000000 | 1.000000 |
# Affichage du nombre de valeurs uniques pour chaque variable
print(diabete.nunique())
Pregnancies 17 Glucose 136 BloodPressure 47 SkinThickness 51 Insulin 186 BMI 248 DiabetesPedigreeFunction 517 Age 52 Outcome 2 dtype: int64
# Affichage du nombre de valeurs manquantes pour chaque variable
print(diabete.isnull().sum())
Pregnancies 0 Glucose 0 BloodPressure 0 SkinThickness 0 Insulin 0 BMI 0 DiabetesPedigreeFunction 0 Age 0 Outcome 0 dtype: int64
# Histogramme de la variable 'Pregnancies'
diabete['Pregnancies'].hist()
plt.title('Distribution du nombre de grossesses')
plt.xlabel('Nombre de grossesses')
plt.ylabel('Nombre de patientes')
plt.show()
# Histogramme de la variable 'Glucose'
diabete['Glucose'].hist()
plt.title('Distribution de la concentration de glucose')
plt.xlabel('Concentration de glucose')
plt.ylabel('Nombre de patientes')
plt.show()
# Histogramme de la variable 'BloodPressure'
diabete['BloodPressure'].hist()
plt.title('Distribution de la pression artérielle diastolique')
plt.xlabel('Pression artérielle diastolique')
plt.ylabel('Nombre de patientes')
plt.show()
# Histogramme de la variable 'SkinThickness'
diabete['SkinThickness'].hist()
plt.title('Distribution de l\'épaisseur du pli cutané tricipital')
plt.xlabel('Épaisseur du pli cutané tricipital')
plt.ylabel('Nombre de patientes')
plt.show()
# Histogramme de la variable 'Insulin'
diabete['Insulin'].hist()
plt.title('Distribution du taux d\'insuline sérique de 2 heures')
plt.xlabel('Taux d\'insuline sérique de 2 heures')
plt.ylabel('Nombre de patientes')
plt.show()
# Histogramme de la variable 'BMI'
diabete['BMI'].hist()
plt.title('Distribution de l\'indice de masse corporelle')
plt.xlabel('Indice de masse corporelle')
plt.ylabel('Nombre de patientes')
plt.show()
# Histogramme de la variable 'DiabetesPedigreeFunction'
diabete['DiabetesPedigreeFunction'].hist()
plt.title('Distribution de la fonction pedigree du diabète')
plt.xlabel('Fonction pedigree du diabète')
plt.ylabel('Nombre de patientes')
plt.show()
# Histogramme de la variable 'Age'
diabete['Age'].hist()
plt.title('Distribution de l\'âge')
plt.xlabel('Âge')
plt.ylabel('Nombre de patientes')
plt.show()
# Diagramme en barres de la variable 'Outcome'
diabete['Outcome'].value_counts().plot(kind='bar')
plt.title('Distribution de la variable cible')
plt.xlabel('Diabétique (1) ou non diabétique (0)')
plt.ylabel('Nombre de patientes')
plt.xticks(rotation=0)
plt.show()
# Génération des boxplots pour chaque variable numérique sur des graphiques séparés
for col in ['Pregnancies', 'Glucose', 'BloodPressure', 'SkinThickness', 'Insulin', 'BMI', 'DiabetesPedigreeFunction', 'Age']:
sns.boxplot(x=diabete[col])
plt.title(f'Boxplot de la variable "{col}"')
plt.show()
# Génération du pairplot
sns.pairplot(data=diabete, hue='Outcome', diag_kind='hist')
plt.suptitle('Pairplot des variables numériques')
plt.show()
# Génération des boxplots bivariés pour chaque variable numérique sur des graphiques séparés
for col in ['Pregnancies', 'Glucose', 'BloodPressure', 'SkinThickness', 'Insulin', 'BMI', 'DiabetesPedigreeFunction', 'Age']:
sns.boxplot(data=diabete, x='Outcome', y=col)
plt.title(f'Boxplot de la variable "{col}" par rapport à la variable cible "Outcome"')
plt.xlabel('Diabétique (1) ou non diabétique (0)')
plt.ylabel(col)
plt.show()
diabete.head()
| Pregnancies | Glucose | BloodPressure | SkinThickness | Insulin | BMI | DiabetesPedigreeFunction | Age | Outcome | |
|---|---|---|---|---|---|---|---|---|---|
| 0 | 6 | 148 | 72 | 35 | 0 | 33.6 | 0.627 | 50 | 1 |
| 1 | 1 | 85 | 66 | 29 | 0 | 26.6 | 0.351 | 31 | 0 |
| 2 | 8 | 183 | 64 | 0 | 0 | 23.3 | 0.672 | 32 | 1 |
| 3 | 1 | 89 | 66 | 23 | 94 | 28.1 | 0.167 | 21 | 0 |
| 4 | 0 | 137 | 40 | 35 | 168 | 43.1 | 2.288 | 33 | 1 |
# Calcul des statistiques de test de Kruskal-Wallis et des p-valeurs pour chaque variable numérique
num_vars = ['Pregnancies', 'Glucose', 'BloodPressure', 'SkinThickness', 'Insulin', 'BMI', 'DiabetesPedigreeFunction', 'Age']
from scipy.stats import kruskal
p_values = []
for col in num_vars:
h, pval = kruskal(diabete[col][diabete['Outcome']==0], diabete[col][diabete['Outcome']==1])
p_values.append(pval)
# Création d'une liste pour stocker les valeurs de significativité
is_significant = []
# Vérification de la significativité pour chaque p-valeur et stockage dans la liste is_significant
for pval in p_values:
if pval < 0.05:
is_significant.append('Oui')
else:
is_significant.append('Non')
# Affichage des résultats dans un tableau
result_table = pd.DataFrame({'Variable': num_vars, 'P-value': p_values, 'Significative': is_significant})
result_table.set_index('Variable', inplace=True)
print(result_table)
P-value Significative Variable Pregnancies 3.741498e-08 Oui Glucose 1.198015e-39 Oui BloodPressure 7.553110e-05 Oui SkinThickness 1.295554e-02 Oui Insulin 6.563377e-02 Non BMI 9.716371e-18 Oui DiabetesPedigreeFunction 1.195553e-06 Oui Age 1.140509e-17 Oui
# Sélection des variables numériques
num_vars = ['Pregnancies', 'Glucose', 'BloodPressure', 'SkinThickness', 'Insulin', 'BMI', 'DiabetesPedigreeFunction', 'Age']
df_num = diabete[num_vars]
# Génération de la heatmap de corrélation
sns.heatmap(df_num.corr(), cmap='coolwarm', annot=True)
plt.title('Heatmap de corrélation des variables numériques')
plt.show()
# Préparation des données
X = diabete.drop('Outcome', axis=1)
y = diabete['Outcome']
# Division des données en ensemble d'apprentissage et de test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
!pip install xgboost
from xgboost import XGBClassifier
Collecting xgboost Downloading xgboost-2.0.1-py3-none-win_amd64.whl.metadata (2.0 kB) Requirement already satisfied: numpy in c:\users\utilisateur\anaconda3\lib\site-packages (from xgboost) (1.21.5) Requirement already satisfied: scipy in c:\users\utilisateur\anaconda3\lib\site-packages (from xgboost) (1.10.1) Downloading xgboost-2.0.1-py3-none-win_amd64.whl (99.7 MB) ---------------------------------------- 99.7/99.7 MB 4.8 MB/s eta 0:00:00 Installing collected packages: xgboost Successfully installed xgboost-2.0.1
from sklearn.model_selection import GridSearchCV
import time
# Définition des paramètres à optimiser
param_grid = {
# max_depth est la profondeur maximale de chaque arbre. Une valeur plus élevée rendra le modèle plus complexe et pourrait entraîner un surapprentissage.
'max_depth': [3, 4, 5,7,8],
# learning_rate (ou taux d'apprentissage) est le pas d'ajustement effectué à chaque étape de l'optimisation. Une valeur plus faible rendra l'apprentissage plus lent.
'learning_rate': [0.01, 0.1, 0.2],
# n_estimators est le nombre d'arbres à construire.
'n_estimators': [100, 200, 300,500,1000],
}
# Création de l'objet GridSearch
model = XGBClassifier()
grid_search = GridSearchCV(model, param_grid, cv=5, n_jobs=-1, verbose=2)
# Enregistrement du temps actuel
start_time = time.time()
# Entraînement du modèle avec GridSearch
grid_search.fit(X_train, y_train)
# Calcul du temps d'exécution
execution_time = time.time() - start_time
Fitting 5 folds for each of 75 candidates, totalling 375 fits
# Affichage des meilleurs paramètres
print("Best parameters found: ", grid_search.best_params_)
# Affichage du temps d'exécution
print("Temps d'exécution: %.2f secondes" % execution_time)
Best parameters found: {'learning_rate': 0.01, 'max_depth': 3, 'n_estimators': 500}
Temps d'exécution: 41.53 secondes
# Utilisation du meilleur modèle trouvé pour la prédiction
best_model = grid_search.best_estimator_
y_train_pred = best_model.predict(X_train)
y_test_pred = best_model.predict(X_test)
# Classification Report
print("\nTrain Classification Report:")
print(classification_report(y_train, y_train_pred))
print("\nTest Classification Report:")
print(classification_report(y_test, y_test_pred))
Train Classification Report:
precision recall f1-score support
0 0.88 0.93 0.90 401
1 0.85 0.76 0.80 213
accuracy 0.87 614
macro avg 0.86 0.84 0.85 614
weighted avg 0.87 0.87 0.87 614
Test Classification Report:
precision recall f1-score support
0 0.81 0.81 0.81 99
1 0.65 0.65 0.65 55
accuracy 0.75 154
macro avg 0.73 0.73 0.73 154
weighted avg 0.75 0.75 0.75 154
from sklearn.metrics import roc_curve,auc
# Courbe ROC pour le jeu de données test
# Courbe ROC
y_train_pred_prob = best_model.predict_proba(X_train)[:,1]
y_test_pred_prob = best_model.predict_proba(X_test)[:,1]
fpr_test, tpr_test, _ = roc_curve(y_test, y_test_pred_prob)
roc_auc_test = auc(fpr_test, tpr_test)
# Courbe ROC pour le jeu de données d'entraînement
fpr_train, tpr_train, _ = roc_curve(y_train, y_train_pred_prob)
roc_auc_train = auc(fpr_train, tpr_train)
# Affichage des courbes ROC
plt.figure()
plt.plot(fpr_test, tpr_test, color='darkorange', lw=2, label='ROC curve (area = %0.2f) Test' % roc_auc_test)
plt.plot(fpr_train, tpr_train, color='blue', lw=2, label='ROC curve (area = %0.2f) Train' % roc_auc_train)
plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Receiver operating characteristic example')
plt.legend(loc="lower right")
plt.show()
# Importance des variables
importance_scores = best_model.feature_importances_
# Création du DataFrame d'importance des variables
importance_df = pd.DataFrame({
'feature': X.columns,
'importance': importance_scores
}).sort_values(by='importance', ascending=False)
# Affichage du DataFrame d'importance des variables
print(importance_df)
feature importance 1 Glucose 0.300117 5 BMI 0.173770 7 Age 0.149674 6 DiabetesPedigreeFunction 0.083926 0 Pregnancies 0.083335 3 SkinThickness 0.074366 4 Insulin 0.072438 2 BloodPressure 0.062374
Pour plus de détails sur le sujet vous pouvez lire: Interpretable Machine Learning par Christoph Molnar
L'interprétation locale des modèles consiste en un ensemble de techniques destinées à répondre à des questions telles que :
-Pourquoi le modèle a-t-il fait cette prédiction spécifique ?
-Quel a été l'impact de cette valeur de caractéristique spécifique sur la prédiction ?
me: pourquoi une prediction particuliere a ete realisé? quels sont les features qui ont impactés cette prediction ?
LIME =Local Interpretable Model-Agnostic Explanations
LIME est une technique qui permet de créer un modèle simple autour de la prédiction que nous voulons expliquer et utilise ce modèle simple pour donner une explication. LIME peut être utilisé avec n'importe quel modèle de machine learning, pas seulement avec des arbres de décision ou des forêts aléatoires.
L'idée de base de LIME est assez simple. Pour une prédiction donnée, LIME perturbe les entrées de la prédiction et essaie de comprendre comment ces perturbations affectent la sortie du modèle. Les attributs qui affectent le plus la sortie lorsqu'ils sont perturbés sont considérés comme ayant une importance élevée pour cette prédiction spécifique.
#pip install lime
import lime
from lime import lime_tabular
# Création de l'explainer
explainer = lime_tabular.LimeTabularExplainer(X_train.values,
feature_names=X_train.columns.values.tolist(),
class_names=['0','1'],
verbose=True,
mode='classification')
# Choisissez un exemple spécifique à expliquer
i = 3
exp = explainer.explain_instance(X_test.values[i], best_model.predict_proba, num_features=5)
# Afficher l'explication
exp.show_in_notebook(show_table=True)
Intercept 0.3851203604857618 Prediction_local [0.2064985] Right: 0.20050462
La valeur de Shapley, dans le contexte de l'interprétation de modèles d'apprentissage automatique, permet d'évaluer l'impact de chaque caractéristique sur une prédiction donnée. Elle fait cela en calculant la contribution moyenne de chaque caractéristique à la prédiction sur toutes les combinaisons possibles de caractéristiques.
#pip install shap
import shap
# Initialisation du Javascript
shap.initjs()
# Création de l'explainer
explainer = shap.TreeExplainer(grid_search.best_estimator_)
# Calcul des valeurs SHAP pour les instances de test
shap_values = explainer.shap_values(X_test)
# Choisissez un exemple spécifique à expliquer
i = 3 # vous pouvez choisir l'indice de l'exemple que vous souhaitez expliquer
shap.force_plot(explainer.expected_value, shap_values[i,:], X_test.iloc[i,:])
[03:47:35] WARNING: C:\buildkite-agent\builds\buildkite-windows-cpu-autoscaling-group-i-07f6e447eee219473-1\xgboost\xgboost-ci-windows\src\c_api\c_api.cc:1240: Saving into deprecated binary model format, please consider using `json` or `ubj`. Model format will default to JSON in XGBoost 2.2 if not specified.
import matplotlib.pyplot as plt
from xgboost import plot_importance
# Affichage de l'importance des caractéristiques
plot_importance(grid_search.best_estimator_)
plt.show()
# Graphique SHAP résumé pour l'interprétabilité globale
shap.summary_plot(shap_values, X_test)
for feature_name, shap_value in zip(X_train.columns, shap_values[0]):
print(f"Feature: {feature_name}, Shapley Value: {shap_value}")
Feature: Pregnancies, Shapley Value: -0.04579910263419151 Feature: Glucose, Shapley Value: -1.5013666152954102 Feature: BloodPressure, Shapley Value: 0.22114555537700653 Feature: SkinThickness, Shapley Value: -0.04425901547074318 Feature: Insulin, Shapley Value: 0.07518917322158813 Feature: BMI, Shapley Value: -1.337860107421875 Feature: DiabetesPedigreeFunction, Shapley Value: -0.16790781915187836 Feature: Age, Shapley Value: -0.5489351749420166
# Création de l'objet explainer
explainer = shap.TreeExplainer(grid_search.best_estimator_)
# Calcul des valeurs SHAP
shap_values = explainer.shap_values(X_train)
# Tracer le graphique SHAP de synthèse
shap.summary_plot(shap_values, X_train, plot_type="bar")
# Afficher le graphique
plt.show()
[03:50:40] WARNING: C:\buildkite-agent\builds\buildkite-windows-cpu-autoscaling-group-i-07f6e447eee219473-1\xgboost\xgboost-ci-windows\src\c_api\c_api.cc:1240: Saving into deprecated binary model format, please consider using `json` or `ubj`. Model format will default to JSON in XGBoost 2.2 if not specified.
import numpy as np
# Moyenne des valeurs Shapley pour chaque caractéristique
mean_shap_values = np.mean(shap_values, axis=0)
# Création d'un scorecard avec une échelle linéaire
scorecard = {}
for feature, mean_shap_value in zip(X_train.columns, mean_shap_values):
# Utilisez une échelle linéaire (par exemple, multiplier par 100)
score = mean_shap_value * 100
scorecard[feature] = score
scorecard
{'Pregnancies': -0.24697259068489075,
'Glucose': -15.97735732793808,
'BloodPressure': 1.0268524289131165,
'SkinThickness': -1.4536692760884762,
'Insulin': 0.8577169850468636,
'BMI': -12.820124626159668,
'DiabetesPedigreeFunction': -0.32277603168040514,
'Age': -6.844871491193771}
# Définition de la grille de scores pour toutes les variables
score_grid = {
'Pregnancies': {
'>= 10': 5,
'5 to 10': 4,
'2 to 5': 3,
'1 to 2': 2,
'0 to 1': 1,
'near zero': 0
},
'Glucose': {
'>= 10': 5,
'5 to 10': 4,
'2 to 5': 3,
'1 to 2': 2,
'0 to 1': 1,
'near zero': 0
},
'BloodPressure': {
'>= 10': 5,
'5 to 10': 4,
'2 to 5': 3,
'1 to 2': 2,
'0 to 1': 1,
'near zero': 0
},
'SkinThickness': {
'>= 10': 5,
'5 to 10': 4,
'2 to 5': 3,
'1 to 2': 2,
'0 to 1': 1,
'near zero': 0
},
'Insulin': {
'>= 10': 5,
'5 to 10': 4,
'2 to 5': 3,
'1 to 2': 2,
'0 to 1': 1,
'near zero': 0
},
'BMI': {
'>= 10': 5,
'5 to 10': 4,
'2 to 5': 3,
'1 to 2': 2,
'0 to 1': 1,
'near zero': 0
},
'DiabetesPedigreeFunction': {
'>= 10': 5,
'5 to 10': 4,
'2 to 5': 3,
'1 to 2': 2,
'0 to 1': 1,
'near zero': 0
},
'Age': {
'>= 10': 5,
'5 to 10': 4,
'2 to 5': 3,
'1 to 2': 2,
'0 to 1': 1,
'near zero': 0
}
}
# Définition des valeurs Shapley pour un échantillon (vous pouvez remplacer ces valeurs)
shapley_values = shap_values[100]
# Initialisez le score à 0
score = 0
# Parcourez toutes les caractéristiques et attribuez des points en fonction des valeurs Shapley
for feature, value in zip(score_grid.keys(), shap_values[0]):
for category, points in score_grid[feature].items():
if category == '>= 10' and value >= 10:
score += points
elif category == '5 to 10' and 5 <= value < 10:
score += points
elif category == '2 to 5' and 2 <= value < 5:
score += points
elif category == '1 to 2' and 1 <= value < 2:
score += points
elif category == '0 to 1' and 0 <= value < 1:
score += points
elif category == 'near zero' and abs(value) < 0.01:
score += points
print("Score final:", score)
Score final: 2
Cette technique évalue l'importance d'une caractéristique en permutant les valeurs de la caractéristique et en observant l'impact sur le score du modèle.
#pip install eli5
import eli5
from eli5.sklearn import PermutationImportance
perm = PermutationImportance(best_model, random_state=1).fit(X_test, y_test)
eli5.show_weights(perm, feature_names = X_test.columns.tolist())
| Weight | Feature |
|---|---|
| 0.1312 ± 0.0559 | Glucose |
| 0.0169 ± 0.0364 | Age |
| 0.0065 ± 0.0246 | BMI |
| 0.0013 ± 0.0127 | SkinThickness |
| 0.0013 ± 0.0380 | DiabetesPedigreeFunction |
| -0.0039 ± 0.0064 | Pregnancies |
| -0.0091 ± 0.0156 | BloodPressure |
| -0.0104 ± 0.0104 | Insulin |
Le graphique de dépendance partielle (abrégé PDP ou PD plot) montre l'effet marginal qu'une ou deux caractéristiques ont sur le résultat prédit d'un modèle d'apprentissage automatique (J. H. Friedman 200130).
from sklearn.inspection import partial_dependence, PartialDependenceDisplay
# Calculer la dépendance partielle
pdp_goals, axes = partial_dependence(best_model, X_test, features=['Glucose'])
# Créer le display
display = PartialDependenceDisplay.from_estimator(
best_model,
X_test,
features=['Glucose'],
)
# Afficher le graphique
display.plot()
<sklearn.inspection._plot.partial_dependence.PartialDependenceDisplay at 0x2d24bf58f40>
!pip install pycebox
Collecting pycebox Downloading pycebox-0.0.1.tar.gz (4.5 kB) Preparing metadata (setup.py): started Preparing metadata (setup.py): finished with status 'done' Requirement already satisfied: matplotlib in c:\users\utilisateur\anaconda3\lib\site-packages (from pycebox) (3.5.1) Requirement already satisfied: numpy in c:\users\utilisateur\anaconda3\lib\site-packages (from pycebox) (1.21.5) Requirement already satisfied: pandas in c:\users\utilisateur\anaconda3\lib\site-packages (from pycebox) (1.4.2) Requirement already satisfied: six in c:\users\utilisateur\anaconda3\lib\site-packages (from pycebox) (1.16.0) Requirement already satisfied: cycler>=0.10 in c:\users\utilisateur\anaconda3\lib\site-packages (from matplotlib->pycebox) (0.11.0) Requirement already satisfied: fonttools>=4.22.0 in c:\users\utilisateur\anaconda3\lib\site-packages (from matplotlib->pycebox) (4.25.0) Requirement already satisfied: kiwisolver>=1.0.1 in c:\users\utilisateur\anaconda3\lib\site-packages (from matplotlib->pycebox) (1.3.2) Requirement already satisfied: packaging>=20.0 in c:\users\utilisateur\anaconda3\lib\site-packages (from matplotlib->pycebox) (21.3) Requirement already satisfied: pillow>=6.2.0 in c:\users\utilisateur\anaconda3\lib\site-packages (from matplotlib->pycebox) (9.0.1) Requirement already satisfied: pyparsing>=2.2.1 in c:\users\utilisateur\anaconda3\lib\site-packages (from matplotlib->pycebox) (3.0.4) Requirement already satisfied: python-dateutil>=2.7 in c:\users\utilisateur\anaconda3\lib\site-packages (from matplotlib->pycebox) (2.8.2) Requirement already satisfied: pytz>=2020.1 in c:\users\utilisateur\anaconda3\lib\site-packages (from pandas->pycebox) (2021.3) Building wheels for collected packages: pycebox Building wheel for pycebox (setup.py): started Building wheel for pycebox (setup.py): finished with status 'done' Created wheel for pycebox: filename=pycebox-0.0.1-py3-none-any.whl size=3640 sha256=d7d26e63bb812259232ef06e79c97e4c1dc1bb08c5d6919fdbfd5c5e4e7d13bc Stored in directory: c:\users\utilisateur\appdata\local\pip\cache\wheels\cf\59\51\a5fb9b5d2384586d5d2184028d412f6f6b7d5ff79c2b4c7838 Successfully built pycebox Installing collected packages: pycebox Successfully installed pycebox-0.0.1
#
#!pip install pycebox
from pycebox.ice import ice, ice_plot
ice_df = ice(data=X_test, column='Glucose', predict=best_model.predict)
ice_plot(ice_df, c='dimgray', linewidth=0.3, plot_pdp=True, pdp_kwargs={'c': 'red', 'linewidth': 5})
--------------------------------------------------------------------------- ModuleNotFoundError Traceback (most recent call last) Input In [32], in <cell line: 3>() 1 # 2 #!pip install pycebox ----> 3 from pycebox.ice import ice, ice_plot 5 ice_df = ice(data=X_test, column='Glucose', predict=best_model.predict) 6 ice_plot(ice_df, c='dimgray', linewidth=0.3, plot_pdp=True, pdp_kwargs={'c': 'red', 'linewidth': 5}) ModuleNotFoundError: No module named 'pycebox'